/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package main;

import java.io.IOException;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;

/**
 *
 * @author Administrator
 */
public class TienlenScene extends CardGameScene implements IGameDisplay {

    private static final int NUMBER_CARD_IN_HANDS = 13;
    private static final int TIME_FOR_THINK = 30;
    //--------------------------------------------------------------------------
    private int blockType;
    private int lastPlayerFightId;
    private int gameResultOrder;
    private int playerFightId;
    private int numberPlayersStart;
    private int cardMoveIndex;
    private int cardOnTablesIndex;
    private int skipTurnId;
    private int numberBackCards;
    private boolean isDrawClock;
    private boolean isBeginGame;
    private boolean isDrawResutl;
    private boolean isCardMove;
    private boolean isFinishRound;
    private boolean isLastBlock;
    //-----------------------------------------------------------------------
    private boolean[] skipArr;
    private boolean[] finishArr;
//    private boolean[] isPlayingArr;
    private int[] resultOrder;
    private int[] numberCardInHand;
    private int[] cardSendToServer;
    private int[] backCardIds;
    //--------------------------------------------------------------------------
    private Image toiImage;
    private Image resultOrderImages;
    private Image cardImages;
    private Card[] cardOnTables;
    private Card[] cardMoves;
    private Card[] cardToiTrang;
//    private boolean isBack;

    public TienlenScene(MainCanvas parent) {
        super(parent);
        initValue();
        initObject();
        if (gameData.cardInHandId != null && !isViewer) {
            setCardShare(gameData.cardInHandId);
        } else {
            initForView();
        }
    }

    private void initForView() {
        cardToiTrang = null;
        numberCardRemains = NUMBER_CARD_IN_HANDS;
        numberCardInHand = new int[maxPlayer];
        cardOnTables = new Card[30];
        cardMoves = new Card[NUMBER_CARD_IN_HANDS];
        cardInHands = null;
        cardHeight = cardImages.getHeight();
        cardWidth = cardImages.getWidth() / 53;
        topCardInHandInitValue = canvasHeight - cardHeight;
        topCardInHand = topCardInHandInitValue;
        numberPlayersStart = numberPlayers;
        for (int i = 0; i < numberCardRemains; i++) {
            if (i < maxPlayer) {
                numberCardInHand[i] = NUMBER_CARD_IN_HANDS;
            }
        }
        isShowJoin = true;
    }

    private void initValue() {
        timeForThink = TIME_FOR_THINK;
        lastTime = 0;
        blockType = -1;
        lastPlayerFightId = -1;
        playerFightId = -1;
        isDrawClock = true;
        isBeginGame = true;
        gameResultOrder = -1;
        maxPlayer = gameData.getMaxPlayer();
        myViewId = gameData.getMyViewId();
        playerId = gameData.getPlayerId();
        gameTurn = gameData.getFirstTurn();
        isViewer = (myViewId < maxPlayer ? false : true);
        if (isViewer) {
            playerId = 0;
        }
//        playerNames = gameData.getPlayerName();
        gameTurn = gameData.getFirstTurn();
        numberPlayers = gameData.getNumberPlayers();
        gameData.setGameDisplay(this);
    }

    private void initObject() {
        try {
            initArr();
            initImage();
        } catch (IOException ex) {
        }
    }

    private void initArr() {
        skipArr = new boolean[maxPlayer];
        finishArr = new boolean[maxPlayer];
        resultOrder = new int[maxPlayer];
    }

    private void initImage() throws IOException {
        toiImage = Utils.loadImage("toi.png");
        resultOrderImages = Utils.loadImage("number.png");
        cardImages = library.getCardImage();
        Debug.d("card image :" + cardImages.getWidth());
    }

    private void initCardArr() {
        cardToiTrang = null;
        numberCardRemains = NUMBER_CARD_IN_HANDS;
        numberCardInHand = new int[maxPlayer];
        cardOnTables = new Card[30];
        cardMoves = new Card[NUMBER_CARD_IN_HANDS];
        cardInHands = new Card[NUMBER_CARD_IN_HANDS];
    }

    private void setCardShare(int[] cardIds) {
        initCardArr();
        sortCardTienlen(cardIds);
        for (int i = 0; i < numberCardRemains; i++) {
            int id = cardIds[i];
            Debug.d("id:" + id + "," + i);
            cardInHands[i] = new Card(id, Card.STATE_NORMAL, cardImages);
            if (i < maxPlayer) {
                numberCardInHand[i] = NUMBER_CARD_IN_HANDS;
            }
        }
        cardHeight = cardImages.getHeight();
        cardWidth = cardImages.getWidth() / 53;
        topCardInHandInitValue = canvasHeight - cardHeight;
        topCardInHand = topCardInHandInitValue;
        numberPlayersStart = numberPlayers;
        if (checkGameFinish(cardIds, numberCardRemains)) {
            Request.chat("Thưởng tới trắng");
            switchMessengerBox(0, "Thưởng tới trắng");
            String msg = "FN1|" + gameData.getPlayerId();
            for (int i = 0; i < numberCardRemains; i++) {
                msg += "|" + cardIds[i];
            }

            Request.request(msg);
        }
        setCardPosition();
    }

    public void sortCardTienlen(int[] dataArr) {
        for (int i = 0, l = dataArr.length; i < l - 1; i++) {
            for (int j = i; j < l; j++) {
                if ((dataArr[i] % 13 + 11) % 13 > (dataArr[j] % 13 + 11) % 13) {
                    int tg = dataArr[i];
                    dataArr[i] = dataArr[j];
                    dataArr[j] = tg;
                } else if (dataArr[i] % 13 == dataArr[j] % 13) {
                    if (dataArr[i] / 13 > dataArr[j] / 13) {
                        int tg = dataArr[i];
                        dataArr[i] = dataArr[j];
                        dataArr[j] = tg;
                    }
                }
            }
        }

    }

    public void dispose() {
        skipArr = null;
        finishArr = null;
        resultOrder = null;
        numberCardInHand = null;
        cardSendToServer = null;
        backCardIds = null;
        //--------------------------------------------------------------------------
        toiImage = null;
        resultOrderImages = null;
        cardImages = null;
        cardOnTables = null;
        cardMoves = null;
        cardToiTrang = null;
        if (isGoBack) {
            gameData.diposeCardIds();
        }

        super.dispose();
    }
//-------------------------------------------------------------------------------

    protected void paintCardGame(Graphics g) {
        paintCard(g);
        paintPlayer(g);
        paintBarMenu(g);
//        paintGameTurn(g);

    }

    protected void paintGameTurn(Graphics g) {
        PiPoDesigner.drawString(g, gameTurn + "," + playerFightId, PiPoDesigner.COLOR_BLACK, PiPoDesigner.COLOR_WHITE, 100, 30);
    }

    protected void paintBarMenu(Graphics g) {
        if (isShowChatBox || isShowSpeaker) {
            PiPoDesigner.drawString(g, "Đóng", PiPoDesigner.COLOR_BLACK, PiPoDesigner.COLOR_WHITE, leftScreen + 5, canvasHeight - 20);
            PiPoDesigner.drawString(g, "Xóa", PiPoDesigner.COLOR_BLACK, PiPoDesigner.COLOR_WHITE, canvasWidth - 30, canvasHeight - 20);
            PiPoDesigner.drawString(g, "Gửi", PiPoDesigner.COLOR_BLACK, PiPoDesigner.COLOR_WHITE, canvasWidth / 2 - 20, canvasHeight - 20);

            return;
        } else {
            PiPoDesigner.drawString(g, "Menu", PiPoDesigner.COLOR_BLACK, PiPoDesigner.COLOR_WHITE, leftScreen + 5, canvasHeight - 20);
            if (isShowSubMenu) {
                PiPoDesigner.drawString(g, "Đóng", PiPoDesigner.COLOR_BLACK, PiPoDesigner.COLOR_WHITE, canvasWidth - 30, canvasHeight - 20);
                return;
            }
        }
        if (isViewer) {
            if (!isJoinedGame && isShowJoin) {
                PiPoDesigner.drawString(g, "Tham gia", PiPoDesigner.COLOR_BLACK, PiPoDesigner.COLOR_WHITE, canvasWidth / 2 - 20, canvasHeight - 20);
            }
            if (isFinishGame && isJoinedGame) {
                PiPoDesigner.drawString(g, "Tiếp tục", PiPoDesigner.COLOR_BLACK, PiPoDesigner.COLOR_WHITE, canvasWidth / 2 - 20, canvasHeight - 20);
            }
        } else {
            if (!isFinishGame) {
                if (gameTurn == playerId) {
                    PiPoDesigner.drawString(g, "Bỏ lượt", PiPoDesigner.COLOR_BLACK, PiPoDesigner.COLOR_WHITE, canvasWidth - 40, canvasHeight - 20);
                    PiPoDesigner.drawString(g, "Đánh bài", PiPoDesigner.COLOR_BLACK, PiPoDesigner.COLOR_WHITE, canvasWidth / 2 - 25, canvasHeight - 20);
                }
            } else {
                PiPoDesigner.drawString(g, "Tiếp tục", PiPoDesigner.COLOR_BLACK, PiPoDesigner.COLOR_WHITE, canvasWidth / 2 - 20, canvasHeight - 20);
            }
        }

    }

    private void paintPlayer(Graphics g) {
        for (int i = 0; i < maxPlayer; i++) {
            if (gameData.isPlays[i]) {
                paintPlayerInfo(g, i);
            }
        }
    }

    private void paintPlayerInfo(Graphics g, int id) {
        int posId = (id - playerId + maxPlayer) % maxPlayer;
        switch (posId) {
            case 0:
                //avatar
                if (isViewer) {
                    PiPoDesigner.drawString(g, gameData.playerName[id], PiPoDesigner.COLOR_BLACK, PiPoDesigner.COLOR_WHITE, positionX[posId], positionY[posId] - 10);
                    Utils.drawFrame(g, avatarImage, positionX[posId], positionY[posId], gameData.avatarIds[id], gameData.playerGender[id], avatarWidth, avatarHeight);

                    if (isDrawResutl) {
                        g.drawImage(toiImage, positionX[posId], positionY[posId] - 30, 0);
                        Utils.drawFrame(g, resultOrderImages, positionX[posId] + 30, positionY[posId] - 30, resultOrder[id], 0,
                                resultOrderImages.getWidth() / 4, resultOrderImages.getHeight());
                    }
                } else {
                    if (gameTurn == id && isDrawClock && !isDrawResutl) {
                        g.setColor(0x0000FD);
                        g.fillRect(canvasWidth / 2 - 10, positionY[posId] - 30, 20, 17);
                        PiPoDesigner.drawCenterString(g, String.valueOf(timeForThink), PiPoDesigner.COLOR_BLACK, PiPoDesigner.COLOR_WHITE, canvasWidth / 2, positionY[posId] - 30);
                    }
                    if (isDrawResutl) {
                        //draw result
                        PiPoDesigner.drawString(g, gameData.playerName[id], PiPoDesigner.COLOR_BLACK, PiPoDesigner.COLOR_WHITE, positionX[posId], positionY[posId] - 10);
                        Utils.drawFrame(g, avatarImage, positionX[posId], positionY[posId], gameData.avatarIds[id], 0, avatarWidth, avatarHeight);

                        g.drawImage(toiImage, positionX[posId], positionY[posId] - 30, 0);
                        Utils.drawFrame(g, resultOrderImages, positionX[posId] + 30, positionY[posId] - 30, resultOrder[id], 0,
                                resultOrderImages.getWidth() / 4, resultOrderImages.getHeight());
                    }
                }
                break;
            case 1:
                //name
                PiPoDesigner.drawString(g, gameData.playerName[id], PiPoDesigner.COLOR_BLACK, PiPoDesigner.COLOR_WHITE, positionX[posId], positionY[posId] - 10);
                if (!finishArr[id]) {
                    //number
                    if (!isViewer) {
                        g.setColor(0x000000);
                        g.fillRect(positionX[posId] + 15, positionY[posId] + 45, 20, 17);
                        PiPoDesigner.drawString(g, String.valueOf(numberCardInHand[id]), PiPoDesigner.COLOR_BLACK,
                                PiPoDesigner.COLOR_WHITE, positionX[posId] + 17, positionY[posId] + 45);
                        //clock
                        if (gameTurn == id && isDrawClock) {
                            g.setColor(0x0000FD);
                            g.fillRect(positionX[posId] - 5, positionY[posId] + 45, 20, 17);
                            PiPoDesigner.drawCenterString(g, String.valueOf(timeForThink),
                                    PiPoDesigner.COLOR_BLACK, PiPoDesigner.COLOR_WHITE,
                                    positionX[posId] + 2, positionY[posId] + 45);
                        }
                    }
                } else {
                    g.drawImage(toiImage, positionX[posId] - 40, positionY[posId] + 20, 0);
                    //  g.drawImage(resultOraderImages[resultOrder[id]], positionX[posId] - 10, positionY[posId] + 20, 0);
                    Utils.drawFrame(g, resultOrderImages, positionX[posId] - 10, positionY[posId] + 20,
                            resultOrder[id], 0, resultOrderImages.getWidth() / 4, resultOrderImages.getHeight());
                    //draw result
                }
                Utils.drawFrame(g, avatarImage, positionX[posId], positionY[posId], gameData.avatarIds[id], gameData.playerGender[id], avatarWidth, avatarHeight);
                break;
            case 2:
                //name
                PiPoDesigner.drawString(g, gameData.playerName[id], PiPoDesigner.COLOR_BLACK, PiPoDesigner.COLOR_WHITE, positionX[posId], positionY[posId] - 10);
                if (!finishArr[id]) {
                    if (!isViewer) {
                        //nubmer
                        g.setColor(0x000000);
                        g.fillRect(positionX[posId] + 18, positionY[posId] + 40, 20, 17);
                        PiPoDesigner.drawString(g, String.valueOf(numberCardInHand[id]), PiPoDesigner.COLOR_BLACK, PiPoDesigner.COLOR_WHITE, positionX[posId] + 20, positionY[posId] + 40);
                        //clock
                        if (gameTurn == id && isDrawClock) {
                            g.setColor(0x0000FD);
                            g.fillRect(positionX[posId] - 2, positionY[posId] + 40, 20, 17);
                            PiPoDesigner.drawCenterString(g, String.valueOf(timeForThink), PiPoDesigner.COLOR_BLACK, PiPoDesigner.COLOR_WHITE, positionX[posId] + 5, positionY[posId] + 40);

                        }
                    }
                } else {
                    //draw result
                    g.drawImage(toiImage, positionX[posId] - 40, positionY[posId] + 20, 0);
                    //   g.drawImage(resultOrderImages[resultOrder[id]], positionX[posId] - 10, positionY[posId] + 20, 0);
                    Utils.drawFrame(g, resultOrderImages, positionX[posId] - 10, positionY[posId] + 20,
                            resultOrder[id], 0, resultOrderImages.getWidth() / 4, resultOrderImages.getHeight());
                }

                Utils.drawFrame(g, avatarImage, positionX[posId], positionY[posId], gameData.avatarIds[id], gameData.playerGender[id], avatarWidth, avatarHeight);
                break;
            case 3:
                //name
                PiPoDesigner.drawString(g, gameData.playerName[id], PiPoDesigner.COLOR_BLACK, PiPoDesigner.COLOR_WHITE, positionX[posId], positionY[posId] - 10);
                if (!finishArr[id]) {
                    if (!isViewer) {
                        //number
                        g.setColor(0x000000);
                        g.fillRect(positionX[posId] - 5, positionY[posId] + 45, 20, 17);
                        PiPoDesigner.drawString(g, String.valueOf(numberCardInHand[id]), PiPoDesigner.COLOR_BLACK, PiPoDesigner.COLOR_WHITE, positionX[posId] - 2, positionY[posId] + 45);
                        //clock
                        if (gameTurn == id && isDrawClock) {
                            g.setColor(0x0000FD);
                            g.fillRect(positionX[posId] + 15, positionY[posId] + 45, 20, 17);
                            PiPoDesigner.drawCenterString(g, String.valueOf(timeForThink), PiPoDesigner.COLOR_BLACK, PiPoDesigner.COLOR_WHITE, positionX[posId] + 24, positionY[posId] + 45);
                        }
                    }
                } else {
                    //draw result
                    g.drawImage(toiImage, positionX[posId], positionY[posId] - 30, 0);
                    // g.drawImage(resultOrderImages[resultOrder[id]], positionX[posId] + 30, positionY[posId] - 0, 03);
                    Utils.drawFrame(g, resultOrderImages, positionX[posId] + 30, positionY[posId] - 30,
                            resultOrder[id], 0, resultOrderImages.getWidth() / 4, resultOrderImages.getHeight());
                }

                Utils.drawFrame(g, avatarImage, positionX[posId], positionY[posId], gameData.avatarIds[id], gameData.playerGender[id], avatarWidth, avatarHeight);
                break;
        }
    }

    private void paintCard(Graphics g) {
        //paint card in hand
//        try {
        if (numberCardRemains > 0 && !isViewer && cardInHands != null) {
            for (int i = 0; i < numberCardRemains; i++) {
                if (cardInHands[i] != null) {
                    cardInHands[i].paint(g);
                }
//                    Debug.d("id paint :" + cardInHands[i].getCardId() + "," + i);
            }
        }
        if (cardToiTrang != null) {
            for (int i = 0; i < 13; i++) {
                if (cardToiTrang[i] != null) {
                    cardToiTrang[i].paint(g);
                }
            }
        }
        //card on table
        if (cardOnTablesIndex > 0) {
            for (int i = 0; i < cardOnTablesIndex; i++) {
                cardOnTables[i].paint(g);
            }
        }
        // card move
        if (cardMoveIndex > 0) {
            for (int i = 0; i < cardMoveIndex; i++) {
                cardMoves[i].paint(g);
            }
        }
        //hand curseur
        if (handCurseurIndex >= 0 && !isViewer && !isJoinedGame && cardInHands != null) {
            g.drawImage(handCurSeurImage, cardInHands[handCurseurIndex].getX(), cardInHands[handCurseurIndex].getY() - handCurSeurImage.getHeight() - 5 + delta, 0);
        }

    }

//---------------------------------------------------------------------------------
    protected void doGameSoftKeyLeft() {
    }

    protected void doGameSoftKeyRight() {
        if (gameTurn == playerId && !isFinishGame && !isViewer) {
            skipTurn();
            parent.repaint();
            return;
        }
    }

    void doGameKeyCenter() {
        if (isShowChatBox && !isViewer) {
            String messageText = chatBox.getText();
            if (messageText.length() == 0) {
                isShowChatBox = false;
                parent.repaint();
                return;
            }
            if (messageText.length() > 25) {
                dialogString = "Số kí tự chat không vượt quá 25";
                parent.repaint();
                return;
            }

            switchMessengerBox(0, messageText);
            isShowChatBox = false;
            Request.chat(chatBox.getText());
            chatBox.setText("");
            parent.repaint();
            return;
        }
        if (isViewer && !isJoinedGame && isShowJoin) {
            isLoading = true;
            Request.joinGame(gameData.getMyName());
            parent.repaint();
            return;
        }
        if (isFinishGame) {
            isLoading = true;
            if (!isViewer || (isViewer && isJoinedGame)) {
                Request.finishTienlen();
                return;
            }
            parent.repaint();
        }
        if (gameTurn == playerId && !isCardMove && !isLoading && !isViewer) {
            fightChooseCard();
        }
    }

    private void fightChooseCard() {
        int numberCardChoose = 0;
        for (int i = 0; i < numberCardRemains; i++) {
            if (cardInHands[i].getState() == Card.STATE_HEIGHT) {
                numberCardChoose++;
            }
        }
        if (numberCardChoose == 0) {
            return;
        }
        cardSendToServer = new int[numberCardChoose];
        int cardSendIndex = 0;
        for (int i = 0; i < numberCardRemains; i++) {
            if (cardInHands[i].getState() == Card.STATE_HEIGHT) {
                Card card = cardInHands[i];
                cardSendToServer[cardSendIndex] = card.getCardId();
                cardSendIndex++;
            }
        }
        blockType = -1;
        if (checkChooseCard(numberCardChoose)) {
            sortCardTienlen(cardSendToServer);
            Request.fightCardTienlen(playerId, playerFightId, blockType, cardSendToServer);
            showChatQuan(blockType, playerFightId, playerId);
//            playerFightId = playerId;
            initializeMoveCard(numberCardChoose);
            isBeginGame = false;
        }

    }

    private int getPosId(int id) {
        return (id - playerId + maxPlayer) % maxPlayer;
    }

    private void showChatQuan(int blockCardType, int playerBiChat, int playerChat) {
        if (blockCardType == -1) {
            return;
        }
        switch (blockCardType) {
            case 0:
                switchMessengerBox(getPosId(playerBiChat), "Bạn bị chặt 2 cơ");
                switchMessengerBox(getPosId(playerChat), "Chặt 2 cơ");
                break;
            case 1:
                switchMessengerBox(getPosId(playerBiChat), "Bạn bị chặt 2 rô");
                switchMessengerBox(getPosId(playerChat), "Chặt 2 rô");
                break;
            case 2:
                switchMessengerBox(getPosId(playerBiChat), "Bạn bị chặt 2 tép");
                switchMessengerBox(getPosId(playerChat), "Chặt 2 tép");
                break;
            case 3:
                switchMessengerBox(getPosId(playerBiChat), "Bạn bị chặt 2 bích");
                switchMessengerBox(getPosId(playerChat), "Chặt 2 bích");
                break;
            case 4:
                switchMessengerBox(getPosId(playerBiChat), "Bạn bị chặt 2 cơ và 2 rô");
                switchMessengerBox(getPosId(playerChat), "Chặt 2 cơ và 2 rô");
                break;
            case 5:
                switchMessengerBox(getPosId(playerBiChat), "Bạn bị chặt 2 cơ và 2 tép");
                switchMessengerBox(getPosId(playerChat), "Chặt 2 cơ và 2 tép");
                break;
            case 6:
                switchMessengerBox(getPosId(playerBiChat), "Bạn bị chặt 2 cơ và 2 bích");
                switchMessengerBox(getPosId(playerChat), "Chặt 2 cơ và 2 bích");
                break;
            case 7:
                switchMessengerBox(getPosId(playerBiChat), "Bạn bị chặt 2 rô và 2 tép");
                switchMessengerBox(getPosId(playerChat), "Chặt 2 rô và 2 tép");
                break;
            case 8:
                switchMessengerBox(getPosId(playerBiChat), "Bạn bị chặt 2 rô và 2 bích");
                switchMessengerBox(getPosId(playerChat), "Chặt 2 rô và 2 bích");
                break;
            case 9:
                switchMessengerBox(getPosId(playerBiChat), "Bạn bị chặt 2 tép và 2 bích");
                switchMessengerBox(getPosId(playerChat), "Chặt 2 tép và 2 bích");
                break;
            case 10:
                switchMessengerBox(getPosId(playerBiChat), "Bạn bị chặt tứ quý");
                switchMessengerBox(getPosId(playerChat), "Chặt tứ quý");
                break;
            case 11:
                switchMessengerBox(getPosId(playerBiChat), "Bạn bị chặt 2 cơ");
                switchMessengerBox(getPosId(playerChat), "Chặt 2 cơ");
                break;
            case 12:
                switchMessengerBox(getPosId(playerBiChat), "Bạn bị chặt 2 rô");
                switchMessengerBox(getPosId(playerChat), "Chặt 2 rô");
                break;
            case 13:
                switchMessengerBox(getPosId(playerBiChat), "Bạn bị chặt 2 tép");
                switchMessengerBox(getPosId(playerChat), "Chặt 2 tép");
                break;
            case 14:
                switchMessengerBox(getPosId(playerBiChat), "Bạn bị chặt 2 bích");
                switchMessengerBox(getPosId(playerChat), "Chặt 2 bích");
                break;
            case 15:
                switchMessengerBox(getPosId(playerBiChat), "Bạn bị chặt 3 đôi thông");
                switchMessengerBox(getPosId(playerChat), "Chặt 3 đôi thông");
                break;
            case 16:
//                chatReceive[preDB2] = "Bá»‹ cháº·t 4 Ä‘Ã´i thÃ´ng";
//                chatReceive[curUserDB2] = "Cháº·t 4 Ä‘Ã´i thÃ´ng";
                break;
        }
    }

    private void initializeMoveCard(int numberCardMoves) {
        int cardChooseWidth = numberCardMoves * (DISTANCE_HORIZONTAL_CARD - 1) + cardWidth + 2;
        int desX = 0;
        if (positionX[3] + avatarWidth < canvasWidth - cardChooseWidth) {
            desX = Utils.nextInt(positionX[3] + avatarWidth, canvasWidth - cardChooseWidth);
        } else {
            desX = canvasWidth - cardChooseWidth;
        }

        int desY = Utils.nextInt(canvasHeight - cardHeight * 2 - 15, canvasHeight - cardHeight * 2 - 10);

        for (int i = 0; i < numberCardRemains; i++) {
            if (cardInHands[i].getState() == Card.STATE_HEIGHT) {
                Card card = cardInHands[i];
                cardMoves[cardMoveIndex] = card;
                card.initializeMove(card.getX(), card.getY(), desX + DISTANCE_HORIZONTAL_CARD * cardMoveIndex, desY, 8);
                cardMoveIndex++;
                for (int j = i; j < numberCardRemains - 1; j++) {
                    cardInHands[j] = cardInHands[j + 1];
                    parent.repaint();
                }
                cardInHands[numberCardRemains - 1] = null;
                numberCardRemains--;
                handCurseurIndex = i;
                i -= 1;
                isLoading = true;
                parent.repaint();
            }
        }
        setCardPosition();
        if (handCurseurIndex >= numberCardRemains) {
            handCurseurIndex = numberCardRemains - 1;
        }

        parent.repaint();
    }

    private void nextGameTurn() {
        isBeginGame = false;
        isFinishRound = false;
        int preGameTurn = gameTurn;
//        isLastBlock = false;
        Debug.d("preturn :" + preGameTurn);
        for (int i = gameTurn + 1; i <= gameTurn + maxPlayer; i++) {
            int j = i % maxPlayer;
            if (!finishArr[j] && gameData.isPlays[j] && !skipArr[j]) {
                gameTurn = j;
                break;
            }
        }
        Debug.d("game turn :" + gameTurn);
        // Debug.d("id vua danh :" + playerFightId);
        timeForThink = TIME_FOR_THINK;
        isDrawClock = true;
        if (gameTurn == playerFightId) {
            finishRound();
//            if (!isLastBlock) {
//                Debug.d("ko ai du suc chan duoc:" + isLastBlock);
//                nextGameTurn();
//            }
            return;
        }
        //het 1 vong
        if (gameTurn == playerFightId) {
            Debug.d("finish round");
            isFinishRound = true;
            finishRound();
        }
        if (playerFightId != -1) {
            if (finishArr[playerFightId] && gameTurn == preGameTurn) {
                isFinishRound = true;
                finishRound();
                nextGameTurn();
            }
        }

        if (numberBackCards == 0 && !isFinishRound) {
            blockType = -1;
        }

    }

    private void finishRound() {
        Debug.d("finish round");
        for (int i = 0; i < maxPlayer; i++) {
            skipArr[i] = false;
        }
        cardMoveIndex = 0;
        playerFightId = -1;
        numberBackCards = 0;
        cardOnTablesIndex = 0;
        parent.repaint();
    }

    private boolean checkChooseCard(int numberCardChooses) {
        for (int i = 0; i < numberCardChooses - 1; i++) {
            for (int j = i + 1; j < numberCardChooses; j++) {
                if (cardSendToServer[i] % 13 > cardSendToServer[j] % 13) {
                    int tg = cardSendToServer[i];
                    cardSendToServer[i] = cardSendToServer[j];
                    cardSendToServer[j] = tg;
                } else {
                    if (cardSendToServer[i] % 13 == cardSendToServer[j] % 13) {
                        if (cardSendToServer[i] / 13 > cardSendToServer[j] / 13) {
                            int tg = cardSendToServer[i];
                            cardSendToServer[i] = cardSendToServer[j];
                            cardSendToServer[j] = tg;
                        }
                    }
                }
            }
        }
        int[] cardCheck = new int[13];
        boolean isHaveKeyCardInSend = false, isHaveKeyCardInHand = false;
        for (int i = 0; i < numberCardChooses; i++) {
            cardCheck[i] = cardSendToServer[i];
            if (cardCheck[i] == 2) {
                isHaveKeyCardInSend = true;
            }
        }
        //
        if (isBeginGame) {
            for (int i = 0; i < numberCardRemains; i++) {
                if (cardInHands[i].getCardId() == 2) {
                    isHaveKeyCardInHand = true;
                    break;
                }
            }
            if (!isHaveKeyCardInSend && isHaveKeyCardInHand) {
                dialogString = "Bạn phải đánh quân bài có chứa 3 bích";
                parent.repaint();
                return false;
            }
        }
        switch (numberCardChooses) {
            case 1:
                if (checkOneCard(cardCheck, numberCardChooses)) {
                    return true;
                }
                break;
            case 2:
                if (checkTwoCard(cardCheck, numberCardChooses)) {
                    return true;
                }
                break;
            case 3:
                if (checkThreeCard(cardCheck, numberCardChooses)) {
                    return true;
                }
                break;
            case 4:
                if (checkFourCard(cardCheck, numberCardChooses)) {
                    return true;
                }
                break;
            case 5:
                if (checkFiveCard(cardCheck, numberCardChooses)) {
                    return true;
                }
                break;
            case 6:
                if (checkSixCard(cardCheck, numberCardChooses)) {
                    return true;
                }
                break;

            case 8:
                if (checkEightCard(cardCheck, numberCardChooses)) {
                    return true;
                }
            default:
                if (checkDefaultCard(cardCheck, numberCardChooses)) {
                    return true;
                }
                break;
        }
        return false;

    }

    private boolean checkOneCard(int[] cardCheck, int soquan) {
        if (numberBackCards == 0) {
            return true;
        }
        if (soquan != numberBackCards) {
            dialogString = "Không cùng loại với quân trên bàn";
            parent.repaint();
            return false;
        }
        if (cardCheck[0] % 13 == 1) {
            if (backCardIds[0] % 13 != 1) {
                return true;
            } else {
                if (backCardIds[0] / 13 < cardCheck[0] / 13) {
                    return true;
                } else {
                    dialogString = "Nhỏ hơn quân trên bàn";
                    parent.repaint();
                    return false;
                }
            }
        } else {
            if ((backCardIds[0] - 2 + 13) % 13 > (cardCheck[0] - 2 + 13) % 13) {
                dialogString = "Nhỏ hơn quân trên bàn";
                parent.repaint();
                return false;
            }
            if ((backCardIds[0] - 2 + 13) % 13 < (cardCheck[0] - 2 + 13) % 13) {
                return true;
            } else {
                if ((backCardIds[0] - 2 + 13) / 13 < (cardCheck[0] - 2 + 13) / 13) {
                    return true;
                } else {
                    dialogString = "Nhỏ hơn quân trên bàn";
                    parent.repaint();
                    return false;
                }
            }
//            }
        }
    }

    private boolean checkEightCard(int[] cardCheck, int soquan) {
        if (numberBackCards == 0) {
            return true;
        }
        // Kiem tra 4 doi thong
        int kind = 0;
        if (cardCheck[0] % 13 == cardCheck[1] % 13 && cardCheck[2] % 13 == cardCheck[3] % 13 && cardCheck[4] % 13 == cardCheck[5] % 13
                && cardCheck[6] % 13 == cardCheck[7] % 13) {
            if (cardCheck[0] % 13 + 1 == cardCheck[2] % 13 && cardCheck[0] % 13 + 2 == cardCheck[4] % 13
                    && cardCheck[0] % 13 + 3 == cardCheck[6] % 13) {
                kind = 1;
            } else {
                dialogString = "Quân bài đánh không hợp lệ";
                parent.repaint();
                return false;
            }
        }
        //System.out.println("Kiem tra 4 doi thong: " + kind);
        if (kind == 1) { // 4 doi thong
            //System.out.println("Sum Back Card: " + sumbackCard);
            if (numberBackCards == 0) {
                return true;
            }
            if (numberBackCards == 1) {
                if (backCardIds[0] % 13 == 1) {
                    if (backCardIds[0] / 13 == 3) {
                        blockType = 11; // 3 doi thong chat 2 co
                    }
                    if (backCardIds[0] / 13 == 2) {
                        blockType = 12;
                    }
                    if (backCardIds[0] / 13 == 1) {
                        blockType = 13;
                    }
                    if (backCardIds[0] / 13 == 0) {
                        blockType = 14;
                    }
                    return true;
                } else {
                    dialogString = "Không cùng loại với quân trên bàn";
                    parent.repaint();
                    return false;
                }
            }
            if (numberBackCards == 2) {
                if (backCardIds[0] % 13 != 1 || backCardIds[1] % 13 != 1) {
                    dialogString = "Không cùng loại với quân trên bàn";
                    parent.repaint();
                    return false;
                } else {
                    if (backCardIds[1] / 13 == 3 && backCardIds[0] / 13 == 2) {
                        blockType = 4;
                    }
                    if (backCardIds[1] / 13 == 3 && backCardIds[0] / 13 == 1) {
                        blockType = 5;
                    }
                    if (backCardIds[1] / 13 == 3 && backCardIds[0] / 13 == 0) {
                        blockType = 6;
                    }
                    if (backCardIds[1] / 13 == 2 && backCardIds[0] / 13 == 1) {
                        blockType = 7;
                    }
                    if (backCardIds[1] / 13 == 2 && backCardIds[0] / 13 == 0) {
                        blockType = 8;
                    }
                    if (backCardIds[1] / 13 == 1 && backCardIds[0] / 13 == 0) {
                        blockType = 9;
                    }
                    return true;
                }
            }
            if (numberBackCards == 6) {
                if (backCardIds[0] % 13 != backCardIds[1] % 13) {
                    dialogString = "Không cùng loại với quân trên bàn";
                    parent.repaint();
                    return false;
                } else {
                    blockType = 15; // Chat 3 doi thong
                    return true;
                }
            }
            if (numberBackCards == 8) {
                if (backCardIds[0] % 13 == 0) {
                    int tg = backCardIds[0];
                    int tg2 = backCardIds[1];
                    for (int i = 0; i < 6; i++) {
                        backCardIds[i] = backCardIds[i + 2];
                    }
                    backCardIds[6] = tg;
                    backCardIds[7] = tg2;
                }
                if (cardCheck[0] % 13 == 0) {
                    int tg = cardCheck[0];
                    int tg2 = cardCheck[1];
                    for (int i = 0; i < 6; i++) {
                        cardCheck[i] = cardCheck[i + 2];
                    }
                    cardCheck[6] = tg;
                    cardCheck[7] = tg2;
                }
                if (backCardIds[0] % 13 != backCardIds[1] % 13) {
                    dialogString = "Không cùng loại với quân trên bàn";
                    parent.repaint();
                    return false;
                } else {
                    if (cardCheck[7] % 13 > backCardIds[7] % 13) {
                        blockType = 16;
                        return true;
                    } else {
                        if (cardCheck[7] % 13 == backCardIds[7] % 13) {
                            if (cardCheck[7] / 13 > backCardIds[7] / 13) {
                                blockType = 16;
                                return true;
                            } else {
                                dialogString = "Nhỏ hơn quân trên bàn";
                                parent.repaint();
                                return false;
                            }
                        } else {
                            dialogString = "Nhỏ hơn quân trên bàn";
                            parent.repaint();
                            return false;
                        }
                    }
                }
            }
            dialogString = "Không cùng loại với quân trên bàn";
            parent.repaint();
            return false;
        }
        // Kiem tra day 8 quan
        //System.out.println("Kiem tra day");
        if (cardCheck[0] % 13 > 6 || cardCheck[0] % 13 < 2) {
            dialogString = "Quân bài đánh không hợp lệ..";
            parent.repaint();
            return false;
        }
        if (backCardIds[0] % 13 == 0) {
            int tg = backCardIds[0];
            for (int i = 0; i < 7; i++) {
                backCardIds[i] = backCardIds[i + 1];
            }
            backCardIds[7] = tg;
        }
        if (cardCheck[0] % 13 == 0) {
            for (int i = 1; i < soquan; i++) {
                if (cardCheck[i] % 13 != i + 5) {
                    dialogString = "Quân bài đánh không hợp lệ...";
                    parent.repaint();
                    return false;
                }
            }
            kind = 2;
        } else {
            for (int i = 1; i < soquan; i++) {
                if (cardCheck[i] % 13 != cardCheck[0] % 13 + i) {
                    dialogString = "Quân bài đánh không hợp lệ....";
                    parent.repaint();
                    return false;
                }
            }
            kind = 2;
        }
        if (kind == 2) {
            if (numberBackCards == 0) {
                return true;
            }
            if (numberBackCards != 8) {
                dialogString = "Không cùng loại với quân trên bàn";
                parent.repaint();
                return false;
            }
            if (backCardIds[0] % 13 == backCardIds[1] % 13) {
                dialogString = "Không cùng loại với quân trên bàn";
                parent.repaint();
                return false;
            }
            if (cardCheck[0] % 13 == 0) {
                int tg = cardCheck[0];
                for (int i = 0; i < 7; i++) {
                    cardCheck[i] = cardCheck[i + 1];
                }
                cardCheck[7] = tg;
            }
            if (cardCheck[7] % 13 > backCardIds[7] % 13) {
                return true;
            } else {
                if (cardCheck[7] % 13 == backCardIds[7] % 13) {
                    if (cardCheck[7] / 13 > backCardIds[7] / 13) {
                        return true;
                    }
                }
                dialogString = "Nhỏ hơn quân trên bàn";
                parent.repaint();
                return false;
            }
        }
        dialogString = "Quân bài đánh không hợp lệ";
        parent.repaint();
        return false;
    }

    private boolean checkFour2(int[] card, int sumCard) {
        int sum = 0;
        for (int i = 0; i < sumCard; i++) {
            if (card[i] % 13 == 1) {
                sum++;
            }
        }
        if (sum == 4) {
            System.out.println("4 Perfect");
            return true;
        }
        return false;
    }

    private boolean checkFour3(int[] card, int sumCard) {
        int sum = 0;
        for (int i = 0; i < sumCard; i++) {
            if (card[i] % 13 == 2) {
                sum++;
            }
        }
        if (sum == 4) {
            System.out.println("4 Perfect");
            return true;
        }
        return false;
    }

    private boolean checkFivePairPerfect(int[] card, int sumCard) {
        int sumPair1 = 0, sumPair2 = 0;
        int i = 0;
        int oldPair = -1, newPair = -1;
        while (i < sumCard - 1) {
            if (card[i] % 13 == card[i + 1] % 13) {
                sumPair1++;
            }
            i += 1;
        }
        if (sumPair1 >= 5 || sumPair2 >= 5) {
            int kind = 1, sumPair = 0;
            if (sumPair1 >= 5) {
                kind = 0;
            }
            i = 0;
            while (i < sumCard - 1) {
                if (card[i] % 13 == card[i + 1] % 13) {
//                    if (card[i] / 13 == card[i + 1] / 13) {
//                        if (card[i] / 13 / 2 == kind) {
                    newPair = card[i] % 13;
                    if (oldPair < 0 || (oldPair - 1 + 13) % 13 + 1 == (newPair - 1 + 13) % 13) {
                        sumPair++;
                    }
                    oldPair = newPair;
//                        }
                    i += 1;
//                    }
                }
                i += 1;
            }
            System.out.println("Sum Pair: " + sumPair);
            if (sumPair >= 5) {
                System.out.println("Pair Perfect");
                return true;
            }
        }
        return false;
    }

    private boolean checkIncrePerfect(int[] card, int sumCard) {
        for (int i = 0; i < sumCard; i++) {
            if (card[i] % 13 == 2) {
                int sum = 0;
                for (int j = 0; j < sumCard; j++) {
                    if (i != j) {
//                        if (card[i] / 13 != card[j] / 13 || card[j] % 13 == 1) {
                        sum++;
                        if (sum > 1) {
                            break;
                        }
//                        }
                    }
                }
                if (sum <= 1) {
                    System.out.println("Incre Perfect");
                    return true;
                }
            }
        }
        return false;
    }

    private boolean checkGameFinish(int[] card, int sumCard) {
//        if (checkSixPair(card, sumCard)) return true;
        if (checkFivePairPerfect(card, sumCard)) {
            return true;
        }
        if (checkIncrePerfect(card, sumCard)) {
            return true;
        }
//        if (checkThreeSetPerfect(card, sumCard)) return true;
        if (checkFour2(card, sumCard)) {
            return true;
        }
        if (checkFour3(card, sumCard)) {
            return true;
        }
//        if (checkSpecial3Card(card, sumCard)) return true;
        return false;
    }

    private boolean checkDefaultCard(int[] cardCheck, int soquan) {
        if (numberBackCards != soquan && numberBackCards > 0) {
            dialogString = "Không cùng loại với quân trên bàn";
            parent.repaint();
            return false;
        }
//        for (int i = 1; i < soquan; is ++) {
//            if (cardCheck[i] / 13 != cardCheck[0] / 13) {
//                midlet.notice = "Quân bài đánh không hợp lệ";
//                return false;
//            }
//        }
        if (cardCheck[0] % 13 == 0) {
            if (cardCheck[1] % 13 <= 2) {
                dialogString = "Quân bài đánh không hợp lệ";
                parent.repaint();
                return false;
            } else {
                for (int i = soquan - 1; i > 0; i--) {
                    if (cardCheck[i] % 13 != 12 - (soquan - 1 - i)) {
                        dialogString = "Quân bài đánh không hợp lệ";
                        parent.repaint();
                        return false;
                    }
                }
            }
        } else {
            if (cardCheck[0] % 13 < 2) {
                dialogString = "Quân bài đánh không hợp lệ";
                parent.repaint();
                return false;
            } else {
                for (int i = 1; i < soquan; i++) {
                    if ((cardCheck[0] - 1 + 13) % 13 + i != (cardCheck[i] - 1 + 13) % 13) {
                        dialogString = "Quân bài đánh không hợp lệ";
                        parent.repaint();
                        return false;
                    }
                }
            }
        }
        if (numberBackCards == 0) {
            return true;
        }
        if (backCardIds[0] % 13 == 0) {
            int tg = backCardIds[0];
            for (int i = 0; i < soquan - 1; i++) {
                backCardIds[i] = backCardIds[i + 1];
            }
            backCardIds[soquan] = tg;
        }
        if (cardCheck[0] % 13 == 0) {
            int tg = cardCheck[0];
            for (int i = 0; i < soquan - 1; i++) {
                cardCheck[i] = cardCheck[i + 1];
            }
            cardCheck[soquan - 1] = tg;
        }
        if (backCardIds[0] < cardCheck[0]) {
            return true;
        } else {
            dialogString = "Nhỏ hơn quân trên bàn";
            parent.repaint();
            return false;
        }
    }

    private boolean checkFourCard(int[] cardCheck, int numberCards) {
        boolean ok = false;
        if ((cardCheck[0] % 13 == cardCheck[1] % 13) && (cardCheck[0] % 13 == cardCheck[2] % 13)
                && (cardCheck[0] % 13 == cardCheck[3] % 13)) {
            ok = true;
        }
        if ((cardCheck[0] % 13 == 0) && (cardCheck[1] % 13 == 10) && (cardCheck[2] % 13 == 11)
                && (cardCheck[3] % 13 == 12)) {
            ok = true;
        }
        if (cardCheck[0] % 13 + 1 == cardCheck[1] % 13 && cardCheck[1] % 13 + 1 == cardCheck[2] % 13
                && cardCheck[2] % 13 + 1 == cardCheck[3] % 13) {
            if ((cardCheck[3] % 13 < 5) && (cardCheck[3] % 13 > 0)) {
                dialogString = "Quân bài đánh không hợp lệ";
                parent.repaint();
                return false;
            }
            ok = true;
        }
        if (!ok) {
            dialogString = "Quân bài đánh không hợp lệ";
            parent.repaint();
            return false;
        }
        if (numberBackCards == 0) {
            return true;
        }
        if (numberBackCards == 1 || numberBackCards == 2) {
            if (backCardIds[0] % 13 != 1) {
                dialogString = "Không cùng loại với quân trên bàn";
                return false;
            } else {
                if (cardCheck[0] % 13 == cardCheck[1] % 13) { // Tu*' quý
                    if (numberBackCards == 1) {
                        if (backCardIds[0] / 13 == 3) {
                            blockType = 0;
                        }
                        if (backCardIds[0] / 13 == 2) {
                            blockType = 1;
                        }
                        if (backCardIds[0] / 13 == 1) {
                            blockType = 2;
                        }
                        if (backCardIds[0] / 13 == 0) {
                            blockType = 3;
                        }
                    }
                    if (numberBackCards == 2) {
                        if (backCardIds[1] / 13 == 3 && backCardIds[0] / 13 == 2) {
                            blockType = 4;
                        }
                        if (backCardIds[1] / 13 == 3 && backCardIds[0] / 13 == 1) {
                            blockType = 5;
                        }
                        if (backCardIds[1] / 13 == 3 && backCardIds[0] / 13 == 0) {
                            blockType = 6;
                        }
                        if (backCardIds[1] / 13 == 2 && backCardIds[0] / 13 == 1) {
                            blockType = 7;
                        }
                        if (backCardIds[1] / 13 == 2 && backCardIds[0] / 13 == 0) {
                            blockType = 8;
                        }
                        if (backCardIds[1] / 13 == 1 && backCardIds[0] / 13 == 0) {
                            blockType = 9;
                        }
                    }
                    return true;
                } else {
                    dialogString = "Không cùng loại với quân trên bàn";
                    parent.repaint();
                    return false;
                }
            }
        }
        if (numberBackCards == 4) {
            if (backCardIds[0] % 13 == backCardIds[1] % 13) {
                if (cardCheck[0] % 13 != cardCheck[1] % 13) {
                    dialogString = "Quân bài không hợp lệ";
                    parent.repaint();
                    return false;
                } else {
                    if ((cardCheck[0] - 2 + 13) % 13 > (backCardIds[0] - 2 + 13) % 13) {
                        blockType = 10; // Chat tu quy
                        return true;
                    } else {
                        dialogString = "Nhỏ hơn quân trên bàn";
                        parent.repaint();
                        return false;
                    }
                }
            } else {
//                if (cardCheck[0] / 13 != backCard[0] / 13) {
//                    midlet.notice = "Không cùng loại với quân trên bàn";
//                    return false;
//                }
                if (cardCheck[0] % 13 == cardCheck[1] % 13) {
                    dialogString = "Không cùng loại với quân trên bàn";
                    parent.repaint();
                    return false;
                }
                if (backCardIds[0] % 13 == 0) {
                    int tg = backCardIds[0];
                    for (int i = 0; i < 3; i++) {
                        backCardIds[i] = backCardIds[i + 1];
                    }
                    backCardIds[3] = tg;
                }
                if (cardCheck[0] % 13 == 0) {
                    int tg = cardCheck[0];
                    cardCheck[0] = cardCheck[1];
                    cardCheck[1] = cardCheck[2];
                    cardCheck[2] = cardCheck[3];
                    cardCheck[3] = tg;
                }
                if (cardCheck[0] % 13 < backCardIds[0] % 13) {
                    dialogString = "Nhỏ hơn quân trên bàn";
                    parent.repaint();
                    return false;
                } else {
                    if (cardCheck[0] % 13 == backCardIds[0] % 13) {
                        if (cardCheck[3] / 13 < backCardIds[3] / 13) {
                            dialogString = "Nhỏ hơn quân trên bàn";
                            parent.repaint();
                            return false;
                        } else {
                            return true;
                        }
                    } else {
                        return true;
                    }
                }
            }
        }
        dialogString = "Quân bài đánh không hợp lệ";
        parent.repaint();
        return false;
    }

    private boolean checkFiveCard(int[] cardCheck, int soquan) {
        if (cardCheck[4] % 13 < 6 && cardCheck[4] % 13 > 0) {
            dialogString = "Quân bài đánh không hợp lệ";
            parent.repaint();
            return false;
        }
        boolean ok = false;
        if (cardCheck[0] % 13 == 0 && cardCheck[4] % 13 == 12 && cardCheck[3] % 13 == 11
                && cardCheck[2] % 13 == 10 && cardCheck[1] % 13 == 9) {
            ok = true;
        }
        if (cardCheck[0] % 13 + 1 == cardCheck[1] % 13 && cardCheck[1] % 13 + 1 == cardCheck[2] % 13
                && cardCheck[2] % 13 + 1 == cardCheck[3] % 13 && cardCheck[3] % 13 + 1 == cardCheck[4] % 13) {
            ok = true;
        }
        if (!ok) {
            dialogString = "Quân bài đánh không hợp lệ";
            parent.repaint();
            return false;
        }
        if (numberBackCards == 0) {
            return true;
        }
        if (numberBackCards != 5) {
            dialogString = "Không cùng loại với quân trên bàn";
            parent.repaint();
            return false;
        }
        if (backCardIds[0] % 13 == 0) {
            int tg = backCardIds[0];
            for (int i = 0; i < 4; i++) {
                backCardIds[i] = backCardIds[i + 1];
            }
            backCardIds[4] = tg;
        }
        if (cardCheck[0] % 13 == 0) {
            int tg = cardCheck[0];
            for (int i = 0; i < 4; i++) {
                cardCheck[i] = cardCheck[i + 1];
            }
            cardCheck[4] = tg;
        }
        if (cardCheck[0] % 13 < backCardIds[0] % 13) {
            dialogString = "Nhỏ hơn quân trên bàn";
            return false;
        } else {
            if (cardCheck[0] % 13 == backCardIds[0] % 13) {
                if (cardCheck[4] / 13 < backCardIds[4] / 13) {
                    dialogString = "Nhỏ hơn quân trên bàn";
                    parent.repaint();
                    return false;
                }
            }
        }
        return true;
    }

    private boolean checkSixCard(int[] cardCheck, int soquan) {
        int kind = 0;
        if (cardCheck[0] % 13 == 0 && cardCheck[1] % 13 == 8 && cardCheck[2] % 13 == 9 && cardCheck[3] % 13 == 10
                && cardCheck[4] % 13 == 11 && cardCheck[5] % 13 == 12) {
            kind = 1;
        }
        if (cardCheck[0] % 13 + 1 == cardCheck[1] % 13 && cardCheck[1] % 13 + 1 == cardCheck[2] % 13
                && cardCheck[2] % 13 + 1 == cardCheck[3] % 13 && cardCheck[3] % 13 + 1 == cardCheck[4] % 13
                && cardCheck[4] % 13 + 1 == cardCheck[5] % 13) {
            kind = 1;
        }
        // kiem tra 3 doi thong
        if (cardCheck[4] % 13 != 1) {
            if ((cardCheck[0] % 13 == cardCheck[1] % 13) && (cardCheck[2] % 13 == cardCheck[3] % 13)
                    && (cardCheck[4] % 13 == cardCheck[5] % 13)) {
                System.out.println("Card check: " + cardCheck[0] + " " + cardCheck[2] + " " + cardCheck[4]);
                if (cardCheck[0] % 13 == 0 && cardCheck[2] % 13 == 11 && cardCheck[4] % 13 == 12) {
                    kind = 2;
                }
                if (cardCheck[0] % 13 + 1 == cardCheck[2] % 13 && cardCheck[2] % 13 + 1 == cardCheck[4] % 13) {
                    kind = 2;
                }
            }
        }
        if (kind == 0) {
            dialogString = "Quân bài đánh không hợp lệ";
            parent.repaint();
            return false;
        }
        if (numberBackCards == 0) {
            return true;
        }
        if (numberBackCards == 1) {
            if (backCardIds[0] % 13 != 1 || kind == 1) {
                dialogString = "Không cùng loại với quân trên bàn";
                parent.repaint();
                return false;
            } else {
                if (backCardIds[0] / 13 == 3) {
                    blockType = 11; // 3 doi thong chat 2 co
                }
                if (backCardIds[0] / 13 == 2) {
                    blockType = 12;
                }
                if (backCardIds[0] / 13 == 1) {
                    blockType = 13;
                }
                if (backCardIds[0] / 13 == 0) {
                    blockType = 14;
                }
                return true;
            }
        }
        if (numberBackCards == 6) {
            if (backCardIds[0] % 13 != backCardIds[1] % 13) { // day
                if (kind != 1) {
                    dialogString = "Không cùng loại với quân trên bàn";
                    parent.repaint();
                    return false;
                }
                if (backCardIds[0] % 13 == 0) {
                    int tg = backCardIds[0];
                    for (int i = 0; i < 5; i++) {
                        backCardIds[i] = backCardIds[i + 1];
                    }
                    backCardIds[5] = tg;
                }
                if (cardCheck[0] % 13 == 0) {
                    int tg = cardCheck[0];
                    for (int i = 0; i < 5; i++) {
                        cardCheck[i] = cardCheck[i + 1];
                    }
                    cardCheck[5] = tg;
                }
                /////////////////
                if (cardCheck[0] % 13 > backCardIds[0] % 13) {
                    return true;
                } else {
                    if (cardCheck[0] % 13 == backCardIds[0] % 13) {
                        if (cardCheck[5] / 13 > backCardIds[5] / 13) {
                            return true;
                        }
                    }
                    dialogString = "Nhỏ hơn quân trên bàn";
                    parent.repaint();
                    return false;
                }
            } else { // 3 doi thong
                if (backCardIds[0] % 13 == 0) {
                    int tg = backCardIds[0];
                    int tg2 = backCardIds[1];
                    for (int i = 0; i < 4; i++) {
                        backCardIds[i] = backCardIds[i + 2];
                    }
                    backCardIds[4] = tg;
                    backCardIds[5] = tg2;
                }
                if (cardCheck[0] % 13 == 0) {
                    int tg = cardCheck[0];
                    int tg2 = cardCheck[1];
                    for (int i = 0; i < 4; i++) {
                        cardCheck[i] = cardCheck[i + 2];
                    }
                    cardCheck[4] = tg;
                    cardCheck[5] = tg2;
                }
                //
                if (kind != 2) {
                    dialogString = "Không cùng loại với quân trên bàn";
                    parent.repaint();
                    return false;
                }
                if ((cardCheck[5] + 12) % 13 > (backCardIds[5] + 12) % 13) {
                    blockType = 15; //Chat 3 doi thong
                    return true;
                } else {
                    if (((cardCheck[5] + 12) % 13 == (backCardIds[5] + 12) % 13)) {
                        if (cardCheck[5] / 13 > backCardIds[5] / 13) {
                            return true;
                        }
                    }
                    dialogString = "Nhỏ hơn quân trên bàn";
                    parent.repaint();
                    return false;
                }
            }
        }
        dialogString = "Quân bài đánh không hợp lệ";
        parent.repaint();
        return false;
    }

    private boolean checkThreeCard(int[] cardCheck, int soquan) {
        boolean ok = false;
        if ((cardCheck[0] % 13 == cardCheck[1] % 13) && (cardCheck[1] % 13 == cardCheck[2] % 13)) {
            ok = true;
        }
        if (cardCheck[0] % 13 == 1 && cardCheck[1] % 13 == 2 && cardCheck[2] % 13 == 3) {
            dialogString = "Quân bài đánh không hợp lệ";
            parent.repaint();
            return false;
        }
        if (cardCheck[0] % 13 == 0 && cardCheck[1] % 13 == 1 && cardCheck[2] % 13 == 2) {
            dialogString = "Quân bài đánh không hợp lệ";
            parent.repaint();
            return false;
        }
        //System.out.println("Card: " + cardCheck[0] + " " + cardCheck[1] + " " + cardCheck[2]);
        if (((cardCheck[0] % 13) + 1 == cardCheck[1] % 13) && ((cardCheck[1] % 13) + 1 == cardCheck[2] % 13)) {
            ok = true;
        }
        if ((cardCheck[0] % 13 == 0) && (cardCheck[1] % 13 == 11) && (cardCheck[2] % 13 == 12)) {
            ok = true;
        }
//        }
        if (!ok) {
            dialogString = "Quân bài không hợp lệ";
            parent.repaint();
            return false;
        }
        if (numberBackCards == 0) {
            return true;
        }
        if (numberBackCards != soquan) {
            dialogString = "Không cùng loại với quân trên bàn";
            parent.repaint();
            return false;
        }
        if (backCardIds[0] % 13 == backCardIds[1] % 13) {
            if (cardCheck[0] % 13 == cardCheck[1] % 13) {
                if ((cardCheck[0] - 2 + 13) % 13 > (backCardIds[0] - 2 + 13) % 13) {
                    return true;
                } else {
                    dialogString = "Không cùng loại với quân trên bàn";
                    parent.repaint();
                    return false;
                }
            } else {
                dialogString = "Không cùng loại với quân trên bàn";
                parent.repaint();
                return false;
            }
        } else {
            if (cardCheck[0] % 13 != cardCheck[1] % 13) {
                if (backCardIds[0] % 13 == 0) {
                    int tg = backCardIds[0];
                    backCardIds[0] = cardCheck[1];
                    backCardIds[1] = cardCheck[2];
                    backCardIds[2] = tg;
                }
                if (cardCheck[0] % 13 == 0) {
                    int tg = cardCheck[0];
                    cardCheck[0] = cardCheck[1];
                    cardCheck[1] = cardCheck[2];
                    cardCheck[2] = tg;
                }
//                if (cardCheck[0] / 13 == backCard[0] / 13) {
                if ((cardCheck[0] + 12) % 13 > (backCardIds[0] + 12) % 13) {
                    return true;
                } else {
                    if (cardCheck[0] % 13 == backCardIds[0] % 13) {
                        if (cardCheck[2] / 13 > backCardIds[2] / 13) {
                            return true;
                        } else {
                            dialogString = "Nhỏ hơn quân trên bàn";
                            parent.repaint();
                            return false;
                        }
                    } else {
                        dialogString = "Nhỏ hơn quân trên bàn";
                        parent.repaint();
                        return false;
                    }
                }
            } else {
                dialogString = "Không cùng loại với quân trên bàn";
                parent.repaint();
                return false;
            }
        }
    }

    private boolean checkTwoCard(int[] cardCheck, int soquan) {
        if (cardCheck[0] % 13 != cardCheck[1] % 13) {
            dialogString = "Hai quân bài không cùng loại";
            parent.repaint();
            return false;
        }

        if (numberBackCards == 0) {
            return true;
        }
        if (numberBackCards != soquan) {
            dialogString = "Không cùng loại với quân trên bàn";
            parent.repaint();
            return false;
        }
        if (backCardIds[0] % 13 == 1) {
            if (cardCheck[0] % 13 == 1) {
                if (cardCheck[1] / 13 > backCardIds[1] / 13) {
                    return true;
                }
                dialogString = "Nhỏ hơn quân trên bàn";
                parent.repaint();
                return false;
            } else {
                dialogString = "Nhỏ hơn quân trên bàn";
                parent.repaint();
                return false;
            }
        } else {
            if (cardCheck[0] % 13 == 1) {
                return true;
            }

            if ((cardCheck[0] - 2 + 13) % 13 < (backCardIds[0] - 2 + 13) % 13) {
                dialogString = "Nhỏ hơn quân trên bàn";
                parent.repaint();
                return false;
            } else {
                if ((cardCheck[0] - 2 + 13) % 13 == (backCardIds[0] - 2 + 13) % 13) {
                    if ((cardCheck[1] - 2 + 13) / 13 < (backCardIds[1] - 2 + 13) / 13) {
                        dialogString = "Nhỏ hơn quân trên bàn";
                        parent.repaint();
                        return false;
                    } else {
                        return true;
                    }
                }
                return true;
            }
        }
    }

//---------------------------------------------------------------------------------
    private int checkCardFinish(int[] card, int sumCard, StringBuffer buffer, StringBuffer chatBuffer) {
        int sumCheck = 0;
        boolean[] b = new boolean[sumCard];
        for (int i = 0; i < sumCard; i++) {
            b[i] = true;
        }
        // Sort Card
        for (int i = 0; i < sumCard - 1; i++) {
            for (int j = i + 1; j < sumCard; j++) {
                if (card[i] % 13 > card[j] % 13) {
                    int tg = card[i];
                    card[i] = card[j];
                    card[j] = tg;
                } else {
                    if (card[i] % 13 == card[j] % 13) {
                        if (card[i] / 13 > card[j] / 13) {
                            int tg = card[i];
                            card[i] = card[j];
                            card[j] = tg;
                        }
                    }
                }
            }
        }
        for (int i = 0; i < sumCard - 4; i++) {
            if (card[i] % 13 == card[i + 1] % 13 && card[i] % 13 == card[i + 2] % 13 && card[i] % 13 == card[i + 3] % 13) {
                chatBuffer.append("Thúi tứ quý");
                buffer.append(1);
                sumCheck = 1;
                b[i] = false;
                b[i + 1] = false;
                b[i + 2] = false;
                b[i + 3] = false;
                break;
            }
        }
        for (int i = 0; i < sumCard - 6; i++) {
            if (card[i] % 13 == card[i + 1] % 13 && card[i] % 13 > 1 && card[i] % 13 < 12) {
                boolean ok1 = false, ok2 = false;
                for (int j = i + 2; j < sumCard - 1; j++) {
//                    if (card[j] / 13 == card[j + 1] / 13 && card[j] / 13 == card[i] / 13) {
                    if (card[j] % 13 == card[j + 1] % 13) {
                        if (card[i] % 13 + 1 == card[j] % 13) {
                            ok1 = true;
                        }
                        if (card[i] % 13 + 2 == card[j] % 13) {
                            ok2 = true;
                        }
                    }
//                    }
                }
                if (ok1 && ok2) {
                    if (sumCheck == 0) {
                        chatBuffer.append("Thúi 3 đôi thông");
                    } else {
                        chatBuffer.append(", 3 đôi thông");
                    }
                    sumCheck += 2;
                    buffer.append(2);
                    break;
                }
            }
        }
        for (int i = 0; i < sumCard; i++) {
            if (card[i] == 1) {
                if (sumCheck == 0) {
                    chatBuffer.append("Thúi 2 bích");
                } else {
                    chatBuffer.append(", 2 bích");
                }
                sumCheck += 4;
                buffer.append(4);
            }
            if (card[i] == 14) {
                if (sumCheck == 0) {
                    chatBuffer.append("Thúi 2 tép");
                } else {
                    chatBuffer.append(", 2 tép");
                }
                sumCheck += 8;
                buffer.append(8);
            }
            if (card[i] == 27) {
                if (sumCheck == 0) {
                    chatBuffer.append("Thúi 2 rô");
                } else {
                    chatBuffer.append(", 2 rô");
                }
                sumCheck += 16;
                buffer.append(16);

            }
            if (card[i] == 40) {
                if (sumCheck == 0) {
                    chatBuffer.append("Thúi 2 cơ");
                } else {
                    chatBuffer.append(", 2 cơ");
                }
                sumCheck += 32;
                buffer.append(32);

            }
        }

        return sumCheck;
    }

    private void checkFinish() {
        int[] card = new int[NUMBER_CARD_IN_HANDS];
        for (int i = 0; i < numberCardRemains; i++) {
            card[i] = cardInHands[i].getCardId();
        }
        StringBuffer buffer = new StringBuffer();
        StringBuffer chatBuffer = new StringBuffer();

        buffer.append("TH|").append(playerId).append("|").append(playerId).append("|");
        int sumCheck = checkCardFinish(card, numberCardRemains, buffer, chatBuffer);
        if (sumCheck > 0) {
            switchMessengerBox(getPosId(playerId), chatBuffer.toString());
            Request.chat(chatBuffer.toString());
            Request.request(buffer.toString());
        }
    }

    public void processMessage(String[] part) {
        super.processMessage(part);
        if (part[0].equals("DB2")) {
            processDBMessage(part);
            isDrawClock = true;
            hideMessage();
            parent.repaint();
            return;
        }
        if (part[0].equals("UPAS")) {
            gameData.setTablePass(part);
            return;
        }
        if (part[0].equals("SE")) {
            isLoading = false;
            gameData.setNumberPlayerInTable(part);
            showChooseTable();
            isGoBack = true;
            parent.repaint();
            return;
        }
        if (part[0].equals("SM")) {
            gameData.setTableMoneyBet(part);
            return;
        }
        if (part[0].equals("RO")) {
            gameData.setRoArrData(part);
            Debug.d("number player :" + numberPlayers);
            if (numberPlayers == 1
                    || numberPlayers - gameResultOrder - 2 == 0) {
                isFinishGame = true;
                isDrawResutl = true;
            }
            if (!gameData.isPlays[gameTurn] && !isFinishGame) {
                nextGameTurn();
            }
            if (numberPlayers < maxPlayer && isViewer) {
                isShowJoin = true;
            }
            parent.repaint();
            return;
        }
        if (part[0].equals("BL")) {
            if (!isFinishGame) {
                skipTurnId = Integer.parseInt(part[1]);
                Debug.d("skip turn id :" + skipTurnId + "," + numberBackCards);
                if (numberBackCards > 0) {
                    skipArr[skipTurnId] = true;
                }
                int posId = (skipTurnId - playerId + maxPlayer) % maxPlayer;
                switchMessengerBox(posId, "Bỏ lượt");
                isLoading = false;
                isDrawClock = true;
                nextGameTurn();
                parent.repaint();
            }
            return;
        }
        if (part[0].equals("FN1")) {
            int idFinish = Integer.parseInt(part[1]);
            for (int i = 0; i < maxPlayer; i++) {
                if (gameData.isPlays[i]) {
                    resultOrder[i] = (i == idFinish ? 0 : 1);
                    finishArr[i] = true;
                }
            }
            cardToiTrang = new Card[13];
            int cardChooseWidth = 13 * (DISTANCE_HORIZONTAL_CARD - 1) + cardWidth + 2;
            for (int i = 0; i < 13; i++) {
                cardToiTrang[i] = new Card(Integer.parseInt(part[i + 2]), Card.STATE_NORMAL, cardImages);
                cardToiTrang[i].setPosition(canvasWidth / 2 - cardChooseWidth / 2 + i * DISTANCE_HORIZONTAL_CARD, canvasHeight - cardHeight * 2 - 15);
            }
            if (idFinish != playerId) {
                checkFinish();
            } else {
                numberCardRemains = 0;
            }
            isDrawResutl = true;
            isFinishGame = true;
            parent.repaint();
            return;
        }
        if (part[0].equals("FN2")) {
            int idFinish = Integer.parseInt(part[3]);
            if ((idFinish != playerId) || isViewer) {
                resultOrder[idFinish] = Integer.parseInt(part[1]);
                finishArr[idFinish] = true;
                gameResultOrder = resultOrder[idFinish];
            }
            Debug.d("number player :" + numberPlayers);
            Debug.d("game result order :" + gameResultOrder);
            if (numberPlayers - gameResultOrder - 2 == 0) {
                isDrawResutl = true;
                int lastId = 0;
                for (int i = 0; i < numberPlayers; i++) {
                    if (!finishArr[i] && gameData.isPlays[i]) {
                        finishArr[i] = true;
                        resultOrder[i] = gameResultOrder + 1;
                        lastId = i;
                        break;
                    }
                }
                isFinishGame = true;
                if (playerId == lastId && !isViewer) {
                    checkFinish();
                }

            }
            parent.repaint();
            return;
        }
        if (part[0].equals("ISPLAY")) {
            gameData.setNumberPlayerInTable(part);
            return;
        }
        if (part[0].equals("MO")) {
            gameData.setMoArrData(part);
            return;
        }
        if (part[0].equals("RE") && (isLoading || isJoinedGame)) {
            gameData.setReArrData(part);
            if (isViewer && !isJoinedGame) {
                resetGameForViewer();
                return;
            }
            if (!isViewer || isJoinedGame) {
                isLoading = false;
                isGoBack = true;
                hideMessage();
                showWaitingRoom();
                parent.repaint();
                return;
            }
        }

        if (part[0].equals("CM")) {
            int money = Integer.parseInt(part[2]);
            int id = Integer.parseInt(part[1]);
            int posId = (id - playerId + maxPlayer) % maxPlayer;
            gameData.changeMoney(id, money);
            switchMoneyChange(posId, part[2]);
            parent.repaint();
            return;
        }
        if (part[0].equals("JS")) {
            int joinResult = Integer.parseInt(part[1]);
            if (joinResult == 0) {
                dialogString = "Bàn đã đủ người chơi";
                isJoinedGame = false;
                isShowJoin = false;
            } else {
                isJoinedGame = true;
                dialogString = "Bạn sẽ tham gia ở ván sau";
            }
            isLoading = false;
            parent.repaint();
            return;
        }
        if (part[0].equals("INFO")) {
            gameData.setInfoData(part);
            return;
        }
        if (part[0].equals("CHAT")) {
            int postId = (Integer.parseInt(part[2]) - playerId + maxPlayer) % maxPlayer;
            if (postId != 0) {
                switchMessengerBox(postId, part[1]);
                parent.repaint();
            }
            return;
        }
    }

    private void resetGameForViewer() {
        isDrawResutl = false;
        isFinishGame = false;
        cardOnTablesIndex = 0;
        cardMoveIndex = 0;
        for (int i = 0; i < maxPlayer; i++) {
            finishArr[i] = false;
            skipArr[i] = false;
            numberCardInHand[i] = NUMBER_CARD_IN_HANDS;
        }
        playerId = 0;
        Debug.d("reset game for viewer");
        parent.repaint();
    }

    private void processDBMessage(String[] part) {
        //DB2|id danh|lastActice|chatquan|ID các quân bài
        int db2Id = Integer.parseInt(part[1]);
        if (isViewer) {
            gameTurn = db2Id;
        }
        Debug.d("db2 :" + db2Id);
        Debug.d("playerId :" + playerId);
        int numberFightCard = part.length - 4;
        numberBackCards = numberFightCard;
        playerFightId = db2Id;
        if (playerFightId != -1) {
            numberCardInHand[playerFightId] -= numberFightCard;
        }
        if (!isViewer && playerFightId == playerId) {
            if (numberCardInHand[playerFightId] == 0 && !finishArr[playerId]) {
                // het bai
                showResult();
            }
        }
        if (db2Id != playerId || isViewer) {
            lastPlayerFightId = Integer.parseInt(part[2]);
            blockType = Integer.parseInt(part[3]);
            showChatQuan(blockType, lastPlayerFightId, playerFightId);
            int cardChooseWidth = numberFightCard * (DISTANCE_HORIZONTAL_CARD - 1) + cardWidth + 2;
            int desX = 0;
            if (positionX[3] + avatarWidth < canvasWidth - cardChooseWidth) {
                desX = Utils.nextInt(positionX[3] + avatarWidth, canvasWidth - cardChooseWidth);
            } else {
                desX = canvasWidth - cardChooseWidth;
            }
            int desY = Utils.nextInt(positionY[2] + 10, canvasHeight - cardHeight - cardHeight - 10);
            Debug.d("des X:" + desX);
            Debug.d("des Y:" + desY);
            Debug.d("number fight card:" + numberFightCard);
            backCardIds = new int[numberFightCard];
            for (int i = 0; i < numberFightCard; i++) {
                int cardId = Integer.parseInt(part[i + 4]);
                backCardIds[i] = cardId;
                Card card = new Card(cardId, Card.STATE_MOVE, cardImages);
                int posId = (playerFightId - playerId + maxPlayer) % maxPlayer;
                cardMoves[cardMoveIndex] = card;
                card.initializeMove(positionX[posId] + DISTANCE_HORIZONTAL_CARD * cardMoveIndex, positionY[posId], desX + DISTANCE_HORIZONTAL_CARD * cardMoveIndex, desY, 8);
                cardMoveIndex++;
                Debug.d("card move index :" + cardMoveIndex);
            }
            Debug.d("card move index final :" + cardMoveIndex);
        }
        isLoading = false;
        nextGameTurn();
    }
//-----------------------------------------------------------------------------

    protected void doWhenTimeExpired() {
        if (timeForThink == 0) {
            isDrawClock = false;
            if (gameTurn == playerId && !isViewer) {
                skipTurn();
            }
        }
    }

    public void skipTurn() {
        isLoading = true;
        Request.skipTurnTienlen(playerId);
        //test
        // Request.chat("Bỏ lượt");
//        if (numberBackCards > 0) {
//            skipArr[playerId] = true;
//        }
        parent.repaint();
    }
//-------------------------------------------------------------------------------

    protected void doSubMenu() {
        switch (subMenu.getSelectedIndex()) {
            case 0:
                super.doSubMenu();
                break;
            case 1:
                //loa
                isShowSubMenu = false;
                isShowSpeaker = true;
                speakerBox.setText("");
                parent.repaint();
                break;
        }
    }

    protected void doCardGameLoop() {
        if (cardMoveIndex > 0) {
            moveCard();
            parent.repaint();
        }
        if (isLoading && countFrame % 4 == 0) {
            loadingIndex = (++loadingIndex) % 7;
            parent.repaint();
        }

    }

    private void moveCard() {
        for (int i = 0; i < cardMoveIndex; i++) {
            if (cardMoves[i].getState() == Card.STATE_MOVE) {
                cardMoves[i].move();
            }
            if (cardMoves[cardMoveIndex - 1].getState() == Card.STATE_NORMAL) {
                if (!isLastBlock) {
                    System.arraycopy(cardMoves, 0, cardOnTables, cardOnTablesIndex, cardMoveIndex);
                    cardOnTablesIndex += cardMoveIndex;
                }

                cardMoveIndex = 0;
                isCardMove = false;
                parent.repaint();
            }
        }

    }

    private void showResult() {
        gameResultOrder++;
        resultOrder[playerId] = gameResultOrder;
        finishArr[playerId] = true;
        isDrawResutl = true;
        parent.repaint();
        if (numberPlayers > 2) {
            Request.tienlenFn2(resultOrder[playerId], numberPlayersStart, playerId);
        } else {
            Request.tienlenFn3(resultOrder[playerId], numberPlayersStart, playerId);
        }
    }

    public void doKeyPound() {
    }
}
